பைதான் DRF அங்கீகாரம்: வலுவான APIகளுக்கான டோக்கன் vs. JWT செயலாக்கம்

உங்கள் APIகளைப் பாதுகாப்பது மிக முக்கியம். பைதான் மற்றும் Django REST Framework (DRF) மூலம் APIகளை உருவாக்கும்போது, உங்களுக்குப் பல அங்கீகார விருப்பங்கள் உள்ளன. இந்த கட்டுரை இரண்டு பிரபலமான முறைகளை ஆராய்கிறது: டோக்கன் அங்கீகாரம் மற்றும் JWT (JSON Web Token) அங்கீகாரம், அவற்றின் பலம் மற்றும் பலவீனங்களை ஒப்பிட்டு, நடைமுறை செயலாக்க எடுத்துக்காட்டுகளை வழங்குகிறது.

APIகளில் அங்கீகாரத்தைப் புரிந்துகொள்வது

அங்கீகாரம் என்பது உங்கள் APIயை அணுகும் ஒரு பயனர் அல்லது பயன்பாட்டின் அடையாளத்தை சரிபார்க்கும் செயல்முறையாகும். நன்கு செயல்படுத்தப்பட்ட அங்கீகார அமைப்பு அங்கீகரிக்கப்பட்ட நிறுவனங்கள் மட்டுமே பாதுகாக்கப்பட்ட ஆதாரங்களை அணுக முடியும் என்பதை உறுதி செய்கிறது. RESTful APIகளின் சூழலில், அங்கீகாரம் பொதுவாக ஒவ்வொரு கோரிக்கையுடனும் சான்றுகளை (எ.கா., பயனர்பெயர் மற்றும் கடவுச்சொல்) அனுப்புவதை உள்ளடக்கியது. சேவையகம் இந்த சான்றுகளைச் சரிபார்த்து, சரியானதாக இருந்தால், அணுகலை வழங்குகிறது.

டோக்கன் அங்கீகாரம்

டோக்கன் அங்கீகாரம் என்பது ஒரு எளிய மற்றும் நேரடியான பொறிமுறையாகும். பயனர் வெற்றிகரமாக உள்நுழையும்போது, சேவையகம் ஒரு தனித்துவமான, ரேண்டம் டோக்கனை உருவாக்கி, அதை பயனருடன் தொடர்புபடுத்தி தரவுத்தளத்தில் சேமிக்கிறது. பின்னர் கிளையன்ட் இந்த டோக்கனை அடுத்தடுத்த கோரிக்கைகளின் 'Authorization' ஹெடரில் அனுப்புகிறது. சேவையகம் தரவுத்தளத்திலிருந்து டோக்கனை மீட்டெடுத்து, அதன் செல்லுபடியை சரிபார்த்து, அதற்கேற்ப அணுகலை வழங்குகிறது.

DRF உடன் செயல்படுத்துதல்

DRF டோக்கன் அங்கீகாரத்திற்கான உள்ளமைக்கப்பட்ட ஆதரவை வழங்குகிறது. அதை எவ்வாறு செயல்படுத்துவது என்பது இங்கே:

1. DRF ஐ நிறுவி, அதை உங்கள் Django திட்டத்தில் பதிவு செய்யுங்கள்:

முதலில், உங்களிடம் Django REST Framework நிறுவப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும்:

            pip install djangorestframework
            

              
                Copy
              
            
          

பின்னர், `settings.py` இல் உள்ள உங்கள் `INSTALLED_APPS` இல் சேர்க்கவும்:

            INSTALLED_APPS = [
    ...
    'rest_framework',
]
            

              
                Copy
              
            
          

2. இயல்புநிலை அங்கீகார வகுப்பாக TokenAuthentication திட்டத்தைச் சேர்க்கவும் (விரும்பினால், ஆனால் பரிந்துரைக்கப்படுகிறது):

உங்கள் `settings.py` கோப்பில், பின்வருவனவற்றைச் சேர்க்கவும்:

            REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.TokenAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ],
}
            

              
                Copy
              
            
          

இது உங்கள் API முழுவதும் டோக்கன் அங்கீகாரத்தை உலகளவில் பயன்படுத்தும். `SessionAuthentication` உலாவி அடிப்படையிலான தொடர்புகளுக்காக சேர்க்கப்பட்டுள்ளது, ஆனால் நீங்கள் அதை முற்றிலும் API அடிப்படையிலான பயன்பாட்டிற்கு அகற்றலாம்.

3. ஒவ்வொரு பயனருக்கும் ஒரு டோக்கனை உருவாக்கவும்:

சிக்னல் கையாளுபவரைச் சேர்ப்பதன் மூலம் பயனர்கள் உருவாக்கப்பட்டவுடன் நீங்கள் தானாகவே டோக்கன்களை உருவாக்கலாம். உங்கள் பயன்பாட்டில் `signals.py` என்ற கோப்பை உருவாக்கவும் (எ.கா., `users/signals.py`):

            from django.conf import settings
from django.db.models.signals import post_save
from django.dispatch import receiver
from rest_framework.authtoken.models import Token

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_auth_token(sender, instance=None, created=False, **kwargs):
    if created:
        Token.objects.create(user=instance)
            

              
                Copy
              
            
          

பின்னர், உங்கள் ஆப் உள்ளமைவு வகுப்பின் `ready` முறையில் உங்கள் `users/apps.py` கோப்பில் இந்த `signals.py` கோப்பை இறக்குமதி செய்யவும். `users/apps.py`க்கான எடுத்துக்காட்டு:

            from django.apps import AppConfig

class UsersConfig(AppConfig):
    default_auto_field = 'django.db.BigAutoField'
    name = 'users'

    def ready(self):
        import users.signals
            

              
                Copy
              
            
          

இப்போது நீங்கள் கட்டளை வரியைப் பயன்படுத்தி டோக்குகளை நிர்வகிக்கலாம்:

            python manage.py drf_create_token <username>
            

              
                Copy
              
            
          

4. உங்கள் API காட்சிகளை செயல்படுத்தவும்:

டோக்கன் அங்கீகாரம் தேவைப்படும் ஒரு காட்சியின் எளிய எடுத்துக்காட்டு இங்கே:

            from rest_framework import permissions
from rest_framework.response import Response
from rest_framework.views import APIView

class ExampleView(APIView):
    authentication_classes = [TokenAuthentication]
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request):
        content = {
            'message': 'Hello, ' + request.user.username + '! You are authenticated.',
        }
        return Response(content)
            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `authentication_classes` டோக்கன் அங்கீகாரம் பயன்படுத்தப்பட வேண்டும் என்பதைக் குறிப்பிடுகிறது, மேலும் `permission_classes` அங்கீகரிக்கப்பட்ட பயனர்கள் மட்டுமே காட்சியகத்தை அணுக முடியும் என்பதைக் குறிப்பிடுகிறது.

5. உள்நுழைவு API காட்சியகத்தை சேர்க்கவும்:

வெற்றிகரமான உள்நுழைவில் டோக்கனை உருவாக்க உங்களுக்கு ஒரு எண்ட்பாயிண்ட் தேவை:

            from django.contrib.auth import authenticate
from rest_framework import status
from rest_framework.authtoken.models import Token
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import AllowAny
from rest_framework.response import Response

@api_view(['POST'])
@permission_classes([AllowAny])
def login(request):
    username = request.data.get('username')
    password = request.data.get('password')
    user = authenticate(username=username, password=password)
    if user:
        token, _ = Token.objects.get_or_create(user=user)
        return Response({'token': token.key})
    else:
        return Response({'error': 'Invalid Credentials'}, status=status.HTTP_401_UNAUTHORIZED)
            

              
                Copy
              
            
          

டோக்கன் அங்கீகாரத்தின் நன்மைகள்

• எளிமை: செயல்படுத்த மற்றும் புரிந்து கொள்ள எளிதானது.
• நிலை இல்லாதது: ஒவ்வொரு டோக்கன் கோரிக்கையும் தனியாக நிற்க அனுமதிக்கும் தகவலைக் கொண்டுள்ளது.

டோக்கன் அங்கீகாரத்தின் குறைபாடுகள்

• தரவுத்தள சார்பு: டோக்கனைச் சரிபார்க்க ஒவ்வொரு கோரிக்கைக்கும் தரவுத்தளத் தோற்றம் தேவைப்படுகிறது. இது செயல்திறனை பாதிக்கும், குறிப்பாக அளவில்.
• டோக்கன் ரத்து: டோக்கனை ரத்து செய்ய அதை தரவுத்தளத்திலிருந்து நீக்க வேண்டும், இது சிக்கலானதாக இருக்கும்.
• விரிவாக்கம்: தரவுத்தள மேல்நிலை காரணமாக பெரிய, அதிக ட்ராஃபிக் APIகளுக்கு மிகவும் அளவிடக்கூடிய தீர்வாக இருக்க முடியாது.

JWT (JSON Web Token) அங்கீகாரம்

JWT அங்கீகாரம் என்பது மிகவும் நவீன மற்றும் அதிநவீன அணுகுமுறையாகும். ஒரு JWT என்பது ஒரு சிறிய, URL-பாதுகாப்பான JSON பொருள் ஆகும், இது பயனரைப் பற்றிய உரிமைகோரல்களைக் கொண்டுள்ளது. இந்த உரிமைகோரல்கள் ஒரு ரகசிய விசை அல்லது பொது/தனி விசை ஜோடியைப் பயன்படுத்தி டிஜிட்டல் முறையில் கையொப்பமிடப்படுகின்றன. பயனர் உள்நுழையும்போது, சேவையகம் ஒரு JWT ஐ உருவாக்கி அதை கிளையண்டிற்கு அனுப்புகிறது. பின்னர் கிளையன்ட் இந்த JWT ஐ அடுத்தடுத்த கோரிக்கைகளின் 'Authorization' ஹெடரில் அடங்கும். சேவையகம் தரவுத்தளத்தை அணுக வேண்டிய அவசியமின்றி JWT இன் கையொப்பத்தை சரிபார்க்க முடியும், இது மிகவும் திறமையான மற்றும் அளவிடக்கூடிய தீர்வாக அமைகிறது.

DRF உடன் செயல்படுத்துதல்

DRF JWT அங்கீகாரத்திற்கான உள்ளமைக்கப்பட்ட ஆதரவை வழங்காது, ஆனால் பல சிறந்த நூலகங்கள் அதை ஒருங்கிணைப்பதை எளிதாக்குகின்றன. மிகவும் பிரபலமான ஒன்று `djangorestframework-simplejwt`.

1. `djangorestframework-simplejwt` ஐ நிறுவவும்:

            pip install djangorestframework-simplejwt
            

              
                Copy
              
            
          

2. DRF அமைப்புகளை உள்ளமைக்கவும்:

உங்கள் `settings.py` கோப்பில், பின்வருவனவற்றைச் சேர்க்கவும்:

            REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_simplejwt.authentication.JWTAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ),
}

SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=5),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=1),
    'ROTATE_REFRESH_TOKENS': False,
    'BLACKLIST_AFTER_ROTATION': True,

    'ALGORITHM': 'HS256',
    'SIGNING_KEY': settings.SECRET_KEY,
    'VERIFYING_KEY': None,
    'AUTH_HEADER_TYPES': ('Bearer',),
    'USER_ID_FIELD': 'id',
    'USER_ID_CLAIM': 'user_id',

    'AUTH_TOKEN_CLASSES': ('rest_framework_simplejwt.tokens.AccessToken',),
    'TOKEN_TYPE_CLAIM': 'token_type',
}
            

              
                Copy
              
            
          

அமைப்புகளின் விளக்கம்:

• `ACCESS_TOKEN_LIFETIME`: அணுகல் டோக்கன் எவ்வளவு காலம் செல்லுபடியாகும் (எடுத்துக்காட்டு, 5 நிமிடங்கள்).
• `REFRESH_TOKEN_LIFETIME`: புதுப்பிப்பு டோக்கன் எவ்வளவு காலம் செல்லுபடியாகும் (எடுத்துக்காட்டு, 1 நாள்). புதிய அணுகல் டோக்கன்களைப் பெற புதுப்பிப்பு டோக்கன்கள் பயன்படுத்தப்படுகின்றன, பயனர் மீண்டும் உள்நுழையத் தேவையில்லை.
• `ROTATE_REFRESH_TOKENS`: ஒவ்வொரு பயன்பாட்டிற்கும் பிறகு புதுப்பிப்பு டோக்கன்களை சுழற்றுவதா.
• `BLACKLIST_AFTER_ROTATION`: சுழற்சிக்குப் பிறகு பழைய புதுப்பிப்பு டோக்கன்களை பிளாக்லிஸ்ட் செய்வதா.
• `ALGORITHM`: JWT இல் கையொப்பமிட பயன்படுத்தப்படும் அல்காரிதம் (HS256 ஒரு பொதுவான தேர்வு).
• `SIGNING_KEY`: JWT இல் கையொப்பமிட பயன்படுத்தப்படும் ரகசிய விசை (பொதுவாக உங்கள் Django SECRET_KEY).
• `AUTH_HEADER_TYPES`: அங்கீகார ஹெடரின் வகை (பொதுவாக "Bearer").

3. உள்நுழைவு மற்றும் புதுப்பிப்பு டோக்கன் API காட்சிகளைச் சேர்க்கவும்:

`djangorestframework-simplejwt` டோக்கன்களைப் பெறுவதற்கும் புதுப்பிப்பதற்கும் காட்சிகளை வழங்குகிறது. அவற்றை உங்கள் `urls.py` இல் சேர்க்கவும்:

            from django.urls import path
from rest_framework_simplejwt.views import (
    TokenObtainPairView,
    TokenRefreshView,
)

urlpatterns = [
    path('token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
]
            

              
                Copy
              
            
          

`TokenObtainPairView` வெற்றிகரமான அங்கீகாரத்திற்குப் பிறகு அணுகல் மற்றும் புதுப்பிப்பு டோக்கன்களை வழங்குகிறது. `TokenRefreshView` சரியான புதுப்பிப்பு டோக்கன் வழங்கப்பட்டால் புதிய அணுகல் டோக்கனை வழங்குகிறது.

4. உங்கள் API காட்சிகளை செயல்படுத்தவும்:

JWT அங்கீகாரம் தேவைப்படும் ஒரு காட்சியின் எளிய எடுத்துக்காட்டு இங்கே:

            from rest_framework import permissions
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework_simplejwt.authentication import JWTAuthentication

class ExampleView(APIView):
    authentication_classes = [JWTAuthentication]
    permission_classes = [permissions.IsAuthenticated]

    def get(self, request):
        content = {
            'message': 'Hello, ' + request.user.username + '! You are authenticated.',
        }
        return Response(content)
            

              
                Copy
              
            
          

டோக்கன் அங்கீகார எடுத்துக்காட்டைப் போலவே, `authentication_classes` JWT அங்கீகாரம் பயன்படுத்தப்பட வேண்டும் என்பதைக் குறிப்பிடுகிறது, மேலும் `permission_classes` அங்கீகரிக்கப்பட்ட பயனர்களுக்கு மட்டுமே அணுகலைக் கட்டுப்படுத்துகிறது.

JWT அங்கீகாரத்தின் நன்மைகள்

• அளவிடுதல்: டோக்கன் சரிபார்ப்புக்கு தரவுத்தளத் தோற்றம் தேவையில்லை, இது மிகவும் அளவிடக்கூடியது.
• நிலை இல்லாதது: JWT அங்கீகாரத்திற்கு தேவையான அனைத்து தகவல்களையும் கொண்டுள்ளது.
• தரப்படுத்தப்பட்டது: JWT என்பது பல நூலகங்கள் மற்றும் தளங்களால் ஆதரிக்கப்படும் பரவலாக ஏற்றுக்கொள்ளப்பட்ட தரமாகும்.
• மைக்ரோசர்வீஸ்கள் நட்பு: மைக்ரோசர்வீஸ்கள் கட்டமைப்புகளுக்கு ஏற்றது, ஏனெனில் சேவைகள் JWTகளைச் சரிபார்க்க முடியும்.

JWT அங்கீகாரத்தின் குறைபாடுகள்

• சிக்கலானது: டோக்கன் அங்கீகாரத்தை விட செயல்படுத்த மிகவும் சிக்கலானது.
• டோக்கன் அளவு: JWTகள் எளிய டோக்கன்களை விட பெரியதாக இருக்கலாம், இது அலைவரிசை பயன்பாட்டை அதிகரிக்கும்.
• டோக்கன் ரத்து: JWT ஐ ரத்து செய்வது சவாலானது. ஒருமுறை வழங்கப்பட்டால், அதன் காலாவதியாகும் வரை அது செல்லுபடியாகும். ரத்து செய்யப்பட்ட டோக்கன்களை பிளாக்லிஸ்ட் செய்வது போன்ற வேலைகள் தரவுத்தளச் சார்பை மீண்டும் அறிமுகப்படுத்துகின்றன.

டோக்கன் ரத்து வியூகங்கள்

டோக்கன் மற்றும் JWT அங்கீகார முறைகள் இரண்டிற்கும் அணுகலை ரத்து செய்வதற்கான வழிமுறைகள் தேவை. டோக்கன் ரத்து செய்வதை நீங்கள் எவ்வாறு அணுகலாம் என்பது இங்கே:

டோக்கன் அங்கீகார ரத்து

டோக்கன் அங்கீகாரத்துடன், ரத்து செய்வது நேரடியானது: தரவுத்தளத்திலிருந்து டோக்கனை நீக்கவும்:

            from rest_framework.authtoken.models import Token

try:
    token = Token.objects.get(user=request.user)
    token.delete()
except Token.DoesNotExist:
    pass

            

              
                Copy
              
            
          

JWT அங்கீகார ரத்து

JWT ரத்து செய்வது மிகவும் சிக்கலானது, ஏனெனில் டோக்கன் உள்நாட்டில் உள்ளது மற்றும் சரிபார்ப்புக்கு தரவுத்தளத் தோற்றத்தை நம்பவில்லை (ஆரம்பத்தில்). பொதுவான உத்திகள் பின்வருமாறு:

• டோக்கன் பிளாக்லிஸ்டிங்: ரத்து செய்யப்பட்ட டோக்கன்களை பிளாக்லிஸ்ட்டில் சேமிக்கவும் (எ.கா., தரவுத்தள அட்டவணை அல்லது ரெடிஸ் கேச்). JWT ஐ சரிபார்ப்பதற்கு முன், அது பிளாக்லிஸ்ட்டில் உள்ளதா என சரிபார்க்கவும். `djangorestframework-simplejwt` புதுப்பிப்பு டோக்கன்களை பிளாக்லிஸ்ட் செய்வதற்கான உள்ளமைக்கப்பட்ட ஆதரவை வழங்குகிறது.
• குறுகிய காலாவதி நேரம்: குறுகிய அணுகல் டோக்கன் காலாவதி நேரங்களைப் பயன்படுத்தவும் மற்றும் புதிய அணுகல் டோக்கன்களை அடிக்கடிப் பெற புதுப்பிப்பு டோக்கன்களை நம்பவும். இது சமரசம் செய்யப்பட்ட டோக்கனைப் பயன்படுத்துவதற்கான வாய்ப்பின் சாளரத்தை கட்டுப்படுத்துகிறது.
• புதுப்பிப்பு டோக்கன்களை சுழற்று: ஒவ்வொரு பயன்பாட்டிற்கும் பிறகு புதுப்பிப்பு டோக்கன்களை சுழற்று. இது ஒவ்வொரு முறையும் பழைய டோக்கன்களை செல்லாததாக்கி டோக்கன் திருட்டை தடுக்கும்.

OAuth2 மற்றும் OpenID Connect

மிகவும் சிக்கலான அங்கீகாரம் மற்றும் அங்கீகார காட்சிகளுக்கு, OAuth2 மற்றும் OpenID Connect ஐப் பயன்படுத்தவும். இந்த தரநிலைகள் சான்றுகளைப் பகிராமல் வளங்களுக்கான அணுகலை பிரதிநிதித்துவப்படுத்துவதற்கான வலுவான கட்டமைப்பை வழங்குகின்றன. OAuth2 முதன்மையாக அங்கீகார நெறிமுறையாகும், அதே நேரத்தில் OpenID Connect அங்கீகார சேவைகளை வழங்க OAuth2 இல் கட்டமைக்கிறது. `django-oauth-toolkit` மற்றும் `django-allauth` போன்ற பல Django தொகுப்புகள் OAuth2 மற்றும் OpenID Connect ஐ உங்கள் DRF APIகளில் ஒருங்கிணைப்பதை எளிதாக்குகின்றன.

எடுத்துக்காட்டு சூழ்நிலை: ஒரு பயனர் உங்கள் APIயில் சேமிக்கப்பட்ட அவர்களின் தரவை மூன்றாம் தரப்பு பயன்பாட்டிற்கு அணுகலை வழங்க விரும்புகிறார். OAuth2 மூலம், பயனர் தங்கள் பயனர்பெயர் மற்றும் கடவுச்சொல்லைப் பகிராமல் பயன்பாட்டிற்கு அங்கீகரிக்க முடியும். மாறாக, பயன்பாடு ஒரு அணுகல் டோக்கனைப் பெறுகிறது, அதை வரையறுக்கப்பட்ட அனுமதிகளின் வரம்பிற்குள் பயனரின் தரவை அணுகப் பயன்படுத்தலாம்.

சரியான அங்கீகார முறையைத் தேர்ந்தெடுப்பது

சிறந்த அங்கீகார முறை உங்கள் குறிப்பிட்ட தேவைகளைப் பொறுத்தது:

• எளிமை மற்றும் செயல்படுத்துவதற்கான வேகம்: டோக்கன் அங்கீகாரம் ஆரம்பத்தில் செயல்படுத்த பொதுவாக எளிதானது.
• அளவிடுதல்: JWT அங்கீகாரம் அதிக ட்ராஃபிக் APIகளுக்கு மிகவும் அளவிடக்கூடியது.
• பாதுகாப்பு தேவைகள்: உங்கள் தரவின் உணர்திறன் மற்றும் தேவையான பாதுகாப்பு அளவைக் கவனியுங்கள். OAuth2/OpenID Connect மிகவும் வலுவான பாதுகாப்பு அம்சங்களை வழங்குகின்றன, ஆனால் மிகவும் சிக்கலான செயலாக்கம் தேவைப்படுகிறது.
• மைக்ரோசர்வீஸ்கள் கட்டமைப்பு: JWTகள் மைக்ரோசர்வீஸ்களுக்கு மிகவும் பொருத்தமானவை, ஏனெனில் ஒவ்வொரு சேவையும் டோக்கன்களைச் சரிபார்க்க முடியும்.

API அங்கீகாரத்திற்கான சிறந்த நடைமுறைகள்

• HTTPS ஐப் பயன்படுத்தவும்: கிளையன்ட் மற்றும் சேவையகத்திற்கு இடையே உள்ள தொடர்புகளை எப்போதும் HTTPS ஐப் பயன்படுத்தி குறியாக்கம் செய்யுங்கள், சான்றுகளை ஒட்டுக்கேட்பதிலிருந்து பாதுகாக்கவும்.
• ரகசியங்களை பாதுகாப்பாக சேமிக்கவும்: ரகசிய விசைகள் அல்லது கடவுச்சொற்களை எளிய உரையில் சேமிக்க வேண்டாம். சுற்றுச்சூழல் மாறிகள் அல்லது பாதுகாப்பான கட்டமைப்பு மேலாண்மை கருவிகளைப் பயன்படுத்தவும்.
• விகித வரம்பை செயல்படுத்து: ஒரு குறிப்பிட்ட காலத்திற்குள் ஒரு கிளையன்ட் செய்யக்கூடிய கோரிக்கைகளின் எண்ணிக்கையை கட்டுப்படுத்துவதன் மூலம் விகித வரம்பை செயல்படுத்துவதன் மூலம் உங்கள் API ஐ தவறாகப் பயன்படுத்துவதிலிருந்து பாதுகாக்கவும்.
• உள்ளீட்டைச் சரிபார்க்கவும்: ஊசி தாக்குதல்களைத் தடுக்க அனைத்து உள்ளீட்டுத் தரவையும் முழுமையாகச் சரிபார்க்கவும்.
• கண்காணிக்கவும் மற்றும் உள்நுழையவும்: சந்தேகத்திற்கிடமான செயல்பாட்டிற்காக உங்கள் API ஐக் கண்காணிக்கவும் மற்றும் தணிக்கை நோக்கங்களுக்காக அங்கீகார நிகழ்வுகளைப் பதிவு செய்யவும்.
• நூலகைகளைத் தொடர்ந்து புதுப்பிக்கவும்: பாதுகாப்பு இணைப்பு மற்றும் மேம்பாடுகளிலிருந்து பயனடைய உங்கள் Django, DRF மற்றும் அங்கீகார நூலகைகளைத் தொடர்ந்து புதுப்பிக்கவும்.
• CORS (Cross-Origin Resource Sharing) ஐ செயல்படுத்தவும்: வலை உலாவிகளில் இருந்து உங்கள் API ஐ அணுகுவதற்கு நம்பகமான டொமைன்களை மட்டுமே அனுமதிக்க CORS ஐ சரியாக உள்ளமைக்கவும்.

முடிவுரை

உங்கள் DRF APIகளைப் பாதுகாப்பதற்கு சரியான அங்கீகார முறையைத் தேர்ந்தெடுப்பது முக்கியமானது. டோக்கன் அங்கீகாரம் எளிமையை வழங்குகிறது, அதே நேரத்தில் JWT அங்கீகாரம் அளவிடுதல் மற்றும் நெகிழ்வுத்தன்மையை வழங்குகிறது. API பாதுகாப்புக்கான சிறந்த நடைமுறைகளுடன் ஒவ்வொரு முறையின் நன்மைகள் மற்றும் தீமைகளை புரிந்துகொள்வது, உங்கள் தரவையும் பயனர்களையும் பாதுகாக்கும் வலுவான மற்றும் பாதுகாப்பான APIகளை உருவாக்க உங்களுக்கு உதவும்.

உங்கள் குறிப்பிட்ட தேவைகளைக் கருத்தில் கொண்டு பாதுகாப்பு, செயல்திறன் மற்றும் செயல்படுத்தும் எளிமை ஆகியவற்றை சிறப்பாகச் சமநிலைப்படுத்தும் தீர்வைத் தேர்வு செய்ய நினைவில் கொள்ளுங்கள். மிகவும் சிக்கலான அங்கீகார காட்சிகளுக்கு OAuth2 மற்றும் OpenID Connect ஐ ஆராயுங்கள்.